package de.thwildau.tm.moses.avro.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import de.thwildau.tm.moses.avro.avdl.AliasAnnotation;
import de.thwildau.tm.moses.avro.avdl.Argument;
import de.thwildau.tm.moses.avro.avdl.ArrayType;
import de.thwildau.tm.moses.avro.avdl.AvdlPackage;
import de.thwildau.tm.moses.avro.avdl.AvroIdl;
import de.thwildau.tm.moses.avro.avdl.BaseTypeRef;
import de.thwildau.tm.moses.avro.avdl.BooleanRef;
import de.thwildau.tm.moses.avro.avdl.DefType;
import de.thwildau.tm.moses.avro.avdl.DoubleRef;
import de.thwildau.tm.moses.avro.avdl.EnumFields;
import de.thwildau.tm.moses.avro.avdl.Field;
import de.thwildau.tm.moses.avro.avdl.FixedLengthField;
import de.thwildau.tm.moses.avro.avdl.HexRef;
import de.thwildau.tm.moses.avro.avdl.ImportTypeRef;
import de.thwildau.tm.moses.avro.avdl.Imports;
import de.thwildau.tm.moses.avro.avdl.IntRef;
import de.thwildau.tm.moses.avro.avdl.JavaclassAnnotation;
import de.thwildau.tm.moses.avro.avdl.MapType;
import de.thwildau.tm.moses.avro.avdl.Name;
import de.thwildau.tm.moses.avro.avdl.NamespaceAnnotation;
import de.thwildau.tm.moses.avro.avdl.OrderAnnotation;
import de.thwildau.tm.moses.avro.avdl.Protocol;
import de.thwildau.tm.moses.avro.avdl.RPCMessage;
import de.thwildau.tm.moses.avro.avdl.Record;
import de.thwildau.tm.moses.avro.avdl.ReturnType;
import de.thwildau.tm.moses.avro.avdl.StringRef;
import de.thwildau.tm.moses.avro.avdl.Throws;
import de.thwildau.tm.moses.avro.avdl.UnionType;
import de.thwildau.tm.moses.avro.services.IdlGrammarAccess;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public class IdlSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private IdlGrammarAccess grammarAccess;
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == AvdlPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case AvdlPackage.ALIAS_ANNOTATION:
				if(context == grammarAccess.getAliasAnnotationRule() ||
				   context == grammarAccess.getAnnotationRule() ||
				   context == grammarAccess.getDefinitionsRule()) {
					sequence_AliasAnnotation(context, (AliasAnnotation) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.ARGUMENT:
				if(context == grammarAccess.getArgumentRule()) {
					sequence_Argument(context, (Argument) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.ARRAY_TYPE:
				if(context == grammarAccess.getArrayTypeRule() ||
				   context == grammarAccess.getComplexTypeRefRule() ||
				   context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getFieldTypeRule()) {
					sequence_ArrayType(context, (ArrayType) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.AVRO_IDL:
				if(context == grammarAccess.getAvroIdlRule()) {
					sequence_AvroIdl(context, (AvroIdl) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.BASE_TYPE_REF:
				if(context == grammarAccess.getBaseTypeRefRule() ||
				   context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getFieldTypeRule() ||
				   context == grammarAccess.getReturnTypeRule() ||
				   context == grammarAccess.getUnionFieldTypeRule()) {
					sequence_BaseTypeRef(context, (BaseTypeRef) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.BOOLEAN_REF:
				if(context == grammarAccess.getBooleanRefRule() ||
				   context == grammarAccess.getConstValueRule()) {
					sequence_BooleanRef(context, (BooleanRef) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.DEF_TYPE:
				if(context == grammarAccess.getDefTypeRule() ||
				   context == grammarAccess.getUnionFieldTypeRule()) {
					sequence_DefType(context, (DefType) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.DOUBLE_REF:
				if(context == grammarAccess.getConstValueRule() ||
				   context == grammarAccess.getDoubleRefRule() ||
				   context == grammarAccess.getNumberRefRule()) {
					sequence_DoubleRef(context, (DoubleRef) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.ENUM:
				if(context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getEnumRule()) {
					sequence_Enum(context, (de.thwildau.tm.moses.avro.avdl.Enum) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.ENUM_FIELDS:
				if(context == grammarAccess.getEnumFieldsRule()) {
					sequence_EnumFields(context, (EnumFields) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.ERROR:
				if(context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getErrorRule()) {
					sequence_Error(context, (de.thwildau.tm.moses.avro.avdl.Error) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.FIELD:
				if(context == grammarAccess.getFieldRule()) {
					sequence_Field(context, (Field) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.FIXED_LENGTH_FIELD:
				if(context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getFixedLengthFieldRule()) {
					sequence_FixedLengthField(context, (FixedLengthField) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.HEX_REF:
				if(context == grammarAccess.getConstValueRule() ||
				   context == grammarAccess.getHexRefRule() ||
				   context == grammarAccess.getNumberRefRule()) {
					sequence_HexRef(context, (HexRef) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.IMPORT_TYPE_REF:
				if(context == grammarAccess.getImportTypeRefRule()) {
					sequence_ImportTypeRef(context, (ImportTypeRef) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.IMPORTS:
				if(context == grammarAccess.getImportsRule()) {
					sequence_Imports(context, (Imports) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.INT_REF:
				if(context == grammarAccess.getConstValueRule() ||
				   context == grammarAccess.getIntRefRule() ||
				   context == grammarAccess.getNumberRefRule()) {
					sequence_IntRef(context, (IntRef) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.JAVACLASS_ANNOTATION:
				if(context == grammarAccess.getAnnotationRule() ||
				   context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getJavaclassAnnotationRule()) {
					sequence_JavaclassAnnotation(context, (JavaclassAnnotation) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.MAP_TYPE:
				if(context == grammarAccess.getComplexTypeRefRule() ||
				   context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getFieldTypeRule() ||
				   context == grammarAccess.getMapTypeRule()) {
					sequence_MapType(context, (MapType) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.NAME:
				if(context == grammarAccess.getNameRule()) {
					sequence_Name(context, (Name) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.NAMESPACE_ANNOTATION:
				if(context == grammarAccess.getAnnotationRule() ||
				   context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getNamespaceAnnotationRule()) {
					sequence_NamespaceAnnotation(context, (NamespaceAnnotation) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.ORDER_ANNOTATION:
				if(context == grammarAccess.getAnnotationRule() ||
				   context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getOrderAnnotationRule()) {
					sequence_OrderAnnotation(context, (OrderAnnotation) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.PROTOCOL:
				if(context == grammarAccess.getProtocolRule()) {
					sequence_Protocol(context, (Protocol) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.RPC_MESSAGE:
				if(context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getRPCMessageRule()) {
					sequence_RPCMessage(context, (RPCMessage) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.RECORD:
				if(context == grammarAccess.getDefinitionsRule() ||
				   context == grammarAccess.getRecordRule()) {
					sequence_Record(context, (Record) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.RETURN_TYPE:
				if(context == grammarAccess.getReturnTypeRule()) {
					sequence_ReturnType(context, (ReturnType) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.STRING_REF:
				if(context == grammarAccess.getConstValueRule() ||
				   context == grammarAccess.getStringRefRule()) {
					sequence_StringRef(context, (StringRef) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.THROWS:
				if(context == grammarAccess.getThrowsRule()) {
					sequence_Throws(context, (Throws) semanticObject); 
					return; 
				}
				else break;
			case AvdlPackage.UNION_TYPE:
				if(context == grammarAccess.getFieldRule() ||
				   context == grammarAccess.getUnionTypeRule()) {
					sequence_UnionType(context, (UnionType) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (element+=StringRef element+=StringRef*)
	 */
	protected void sequence_AliasAnnotation(EObject context, AliasAnnotation semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (type=ReturnType name=Name value=ConstValue?)
	 */
	protected void sequence_Argument(EObject context, Argument semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     type=FieldType
	 */
	protected void sequence_ArrayType(EObject context, ArrayType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.COMPLEX_TYPE_REF__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.COMPLEX_TYPE_REF__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getArrayTypeAccess().getTypeFieldTypeParserRuleCall_2_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (nameSpace=NamespaceAnnotation? protocol=Protocol)
	 */
	protected void sequence_AvroIdl(EObject context, AvroIdl semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     basicType=BaseType
	 */
	protected void sequence_BaseTypeRef(EObject context, BaseTypeRef semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     boolean=BOOL
	 */
	protected void sequence_BooleanRef(EObject context, BooleanRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.BOOLEAN_REF__BOOLEAN) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.BOOLEAN_REF__BOOLEAN));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getBooleanRefAccess().getBooleanBOOLEnumRuleCall_0(), semanticObject.getBoolean());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     name=[Definitions|ID]
	 */
	protected void sequence_DefType(EObject context, DefType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.DEF_TYPE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.DEF_TYPE__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDefTypeAccess().getNameDefinitionsIDTerminalRuleCall_0_1(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     double=DOUBLE
	 */
	protected void sequence_DoubleRef(EObject context, DoubleRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.DOUBLE_REF__DOUBLE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.DOUBLE_REF__DOUBLE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDoubleRefAccess().getDoubleDOUBLETerminalRuleCall_0(), semanticObject.getDouble());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_EnumFields(EObject context, EnumFields semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.ENUM_FIELDS__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.ENUM_FIELDS__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getEnumFieldsAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID fields+=EnumFields fields+=EnumFields*)
	 */
	protected void sequence_Enum(EObject context, de.thwildau.tm.moses.avro.avdl.Enum semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID fields+=Field*)
	 */
	protected void sequence_Error(EObject context, de.thwildau.tm.moses.avro.avdl.Error semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((type=FieldType annotation=Annotation? name=ID value=ConstValue?) | (type=DefType annotation=Annotation? name=ID))
	 */
	protected void sequence_Field(EObject context, Field semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID size=INT)
	 */
	protected void sequence_FixedLengthField(EObject context, FixedLengthField semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.FIXED_LENGTH_FIELD__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.FIXED_LENGTH_FIELD__NAME));
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.FIXED_LENGTH_FIELD__SIZE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.FIXED_LENGTH_FIELD__SIZE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getFixedLengthFieldAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getFixedLengthFieldAccess().getSizeINTTerminalRuleCall_3_0(), semanticObject.getSize());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     hex=HEX
	 */
	protected void sequence_HexRef(EObject context, HexRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.HEX_REF__HEX) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.HEX_REF__HEX));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getHexRefAccess().getHexHEXTerminalRuleCall_0(), semanticObject.getHex());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     type=ImportType
	 */
	protected void sequence_ImportTypeRef(EObject context, ImportTypeRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.IMPORT_TYPE_REF__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.IMPORT_TYPE_REF__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getImportTypeRefAccess().getTypeImportTypeParserRuleCall_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (importType=ImportTypeRef importURI=StringRef endLine=EndLine)
	 */
	protected void sequence_Imports(EObject context, Imports semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.IMPORTS__IMPORT_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.IMPORTS__IMPORT_TYPE));
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.IMPORTS__IMPORT_URI) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.IMPORTS__IMPORT_URI));
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.IMPORTS__END_LINE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.IMPORTS__END_LINE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getImportsAccess().getImportTypeImportTypeRefParserRuleCall_1_0(), semanticObject.getImportType());
		feeder.accept(grammarAccess.getImportsAccess().getImportURIStringRefParserRuleCall_2_0(), semanticObject.getImportURI());
		feeder.accept(grammarAccess.getImportsAccess().getEndLineEndLineParserRuleCall_3_0(), semanticObject.getEndLine());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     int=INT
	 */
	protected void sequence_IntRef(EObject context, IntRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.INT_REF__INT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.INT_REF__INT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getIntRefAccess().getIntINTTerminalRuleCall_0(), semanticObject.getInt());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     classpath=StringRef
	 */
	protected void sequence_JavaclassAnnotation(EObject context, JavaclassAnnotation semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.JAVACLASS_ANNOTATION__CLASSPATH) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.JAVACLASS_ANNOTATION__CLASSPATH));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getJavaclassAnnotationAccess().getClasspathStringRefParserRuleCall_2_0(), semanticObject.getClasspath());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     type=FieldType
	 */
	protected void sequence_MapType(EObject context, MapType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.COMPLEX_TYPE_REF__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.COMPLEX_TYPE_REF__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getMapTypeAccess().getTypeFieldTypeParserRuleCall_2_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (value=ID | value='`')
	 */
	protected void sequence_Name(EObject context, Name semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     path=StringRef
	 */
	protected void sequence_NamespaceAnnotation(EObject context, NamespaceAnnotation semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.NAMESPACE_ANNOTATION__PATH) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.NAMESPACE_ANNOTATION__PATH));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getNamespaceAnnotationAccess().getPathStringRefParserRuleCall_2_0(), semanticObject.getPath());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     order=StringRef
	 */
	protected void sequence_OrderAnnotation(EObject context, OrderAnnotation semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.ORDER_ANNOTATION__ORDER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.ORDER_ANNOTATION__ORDER));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getOrderAnnotationAccess().getOrderStringRefParserRuleCall_2_0(), semanticObject.getOrder());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (protocolName=ID imports+=Imports* definitions+=Definitions*)
	 */
	protected void sequence_Protocol(EObject context, Protocol semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (returnType=ReturnType name=Name (args+=Argument args+=Argument*)? throws=Throws?)
	 */
	protected void sequence_RPCMessage(EObject context, RPCMessage semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID (annotation+=Annotation? fields+=Field)*)
	 */
	protected void sequence_Record(EObject context, Record semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     type=[Definitions|ID]
	 */
	protected void sequence_ReturnType(EObject context, ReturnType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.RETURN_TYPE__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.RETURN_TYPE__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getReturnTypeAccess().getTypeDefinitionsIDTerminalRuleCall_1_0_1(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     string=STRING
	 */
	protected void sequence_StringRef(EObject context, StringRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.STRING_REF__STRING) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.STRING_REF__STRING));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getStringRefAccess().getStringSTRINGTerminalRuleCall_0(), semanticObject.getString());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     error=[Error|ID]
	 */
	protected void sequence_Throws(EObject context, Throws semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, AvdlPackage.Literals.THROWS__ERROR) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AvdlPackage.Literals.THROWS__ERROR));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getThrowsAccess().getErrorErrorIDTerminalRuleCall_1_0_1(), semanticObject.getError());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (types+=UnionFieldType types+=UnionFieldType* annotation=Annotation? optionalString=ID?)
	 */
	protected void sequence_UnionType(EObject context, UnionType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
}
